Event-driven component mirroring method and system

ABSTRACT

A technique is provided for exchanging data between software components in interface devices, monitoring devices, control devices, and so forth. Device elements are stored in the devices that are capable of communicating signals to one other, with each device element including a predetermined functionality. A connection is established between the device elements that facilitates event-based transfer of signals. A first of the device elements transfers data resulting from its functionality acting upon the received signals or the received signals themselves to a second device element. The transfer happens upon a receipt of the signals by the first device element. Each of the device elements made and act upon the signals in accordance with this respective functionality. The technique may used to cause interface elements to mirror one another. In other settings, quite different device elements may exchange data in an event-based transfer upon the receipt of the data by one of the elements to carryout the substantially different functionalities in accordance with their own programming.

BACKGROUND

The present invention relates generally to the field of interfacedevices, and monitoring and control devices. More particularly, theinvention relates to techniques for mirroring operation of softwaremodules or components in such devices in coordination with one another.

A wide range of interface devices are known and are presently in use inmany different fields. In industrial automation, for example, humanmachine interfaces or “HMIs” are commonly employed for monitoring orcontrolling various processes. The HMIs may read from or write tospecific registers such that they can reflect the operating state ofvarious machines, sensors, processes, and so forth. The interfaces canalso write to registers and memories such that they can, to some extent,control the functions of the process. In monitoring functions alone,little or no actual control is executed. In many other settings similardevices are employed, such as in automobiles, aircraft, commercialsettings, and a host of other applications. In many applications, theinterface may not communicate with a remote device or process, but maybe operated in a stand-alone manner.

A challenge in complex interface, monitoring and control situationsinvolves the showing of information and states between softwarecomponents. For example, in complex industrial settings, similarsoftware may be resident on in run in different devices and processes,leading to potential inconsistencies in the presentation of information,as well as inefficiencies in network traffic, numeral utilization andprocessing requirements. Few attempts have been made at providing usefullinks between software so as to reduce such redundancies. At most,existing systems may permit different and diverse programmed devices toread from common or shared registers and to write to such registers.However, such software generally still operates independently andwithout significant interaction that could lead to even more complexfunctionality and greater efficiencies.

There is a need, therefore, for improved designs for distributedsoftware and device components, particularly in interfaces and inmonitoring and control devices. There is a particular need forrelatively straightforward approaches to sharing data and states amongsoftware so as to provide similar information at different locations incomplex systems that can be acted on either in identical or differentways by different software.

BRIEF DESCRIPTION

Embodiments of the present invention relate generally to the field ofconfigurable interfaces. In the present context, a “configurableinterface” is any human interface device having embedded and dedicatedcode for accessing settings and displaying user-viewable views orscreens based upon such settings. For example, such configurableinterfaces may be used as operator interfaces for industrial equipment.More particularly, embodiments of the present invention relate totechniques for operation of configurable interfaces, and for accessing,configuring, and creating applications for utilization with suchconfigurable interfaces by serving configuration screens to a browser orsimilar general purpose viewer.

An interface generally may read data from and write to remote memory andparticular registers, such as for interfacing with a process or machine.In other contexts, the interface simply accesses and displays data in astand-alone architecture. For example, the innovations described belowmay be implemented in industrial computer terminals, equipmentinterfaces (e.g., programmable logic controllers and softwareinterfaces), and related devices such as those used in industrial andcommercial settings. When used to interface with a controller, machineor process, the interfaces are sometimes referred to as human-machineinterfaces (HMIs), man-machine interfaces (MMI), graphical userinterfaces (GUI), user interfaces (Ul), operator interfaces (OI), and soforth. The term HMI is generally used in the present discussion.However, as described below, the inventive concepts presented herein arenot limited to interfaces linked to external components and systems.

System Overview

A number of facets, components and processes will be described throughthe following discussion. By way of introduction, a general systemoverview is in order that situates these innovations in context. FIG. 1is a diagrammatical representation of an exemplary control andmonitoring software framework 10 for an interface. The framework 10facilitates building functional software by utilizing a module basedinterconnection mechanism 12, which inherently supports dynamicmanipulation and configuration. This dynamic manipulation andconfiguration ability facilitates efficient provision of feature-richconfiguration environments for configurable interfaces. That is, asdescribed below, individual device elements are provided as stand-alonecode that can be individually programmed, pre-written for use, as in alibrary, customized in their function and appearance in screens, andinterconnected to provide information to a user as well as monitoringand control functions.

The framework 10 includes two interrelated software environments thatcan reside on a single system (e.g., computer). Specifically, A run-timeenvironment 14 enables an operator (e.g., a human user) to interact withan application, such as a process during run-time (e.g., during use ofthe interface, typically during interaction with or observance of aprocess in operation). A design-time environment permits a designer toconfigure the interface and its components. For example, a system maygraphically present run-time information to an operator via the run-timeenvironment 14 on a display (e.g., computer or interface device screen).Further, the system may include means (e.g., a keypad) for acceptingoperator input that can be detected and managed via the run-timeenvironment. The environments interact as described in detail below, ininnovative ways to provide greatly enhanced programming and use of theinterface.

The run-time environment includes or provides access to device elements18. The device elements 18 are software components that may include anyaccessible or configurable element in a software environment. Forexample, the device elements 18 include software components, such as“ActiveX” controls or “.NET” components that are managed by the run-timeenvironment 14. “ActiveX” and “.NET” refer to object-oriented concepts,technologies and tools. Those skilled in the art will be well-acquaintedwith such programming approaches generally. In the present context, suchstandards should be taken as merely examples, and “device elements”should be understood as including any generally similar components orself-sufficient programs that can be run as quasi-independent elements,sometimes referred to as “objects”. Other standards and platforms existfor such elements, typically championed by different companies orindustry groups.

Because such device elements are basic to certain of the inventiveconcepts, a few words of introduction are in order. Device elementsgenerally include four features: properties, methods, connections (orconnection points) and communications interfaces. Properties areattributes that can be adjusted, such as to define an image orrepresentation of the element in a screen view, as well as its locationon the screen, and so forth. A method is an executable function(sometimes referred to herein as the elements “functionality” or “stateengine”), and defines an operation performed by execution of theelement. A connection is a link between elements, and can be used tocause data (read from a memory or written to a memory) to be sent toanother element.

Specific examples of device elements 18 may include softwarepushbuttons, timers, gauges, PLC communication servers, screens, andapplications. In general, virtually any identifiable function may beconfigured as such an element. Moreover, as discussed below, suchelements may communicate with one another to perform a wide range ofdisplay, monitoring operations and control functions. It should be notedthat device elements 18 do not require special limitations forsupporting a design mode. Also, while elements associated with an imageare quite useful, particularly for screen views, many elements may nothave a visual representation, but may perform functions within an HMI,such as calculations, or even management and data exchange between otherelements.

The run-time environment typically operates using a communicationssubsystem 20. The communications subsystem 20 is adapted to interconnectthe device elements 18. In practice, the communications subsystem 20 maybe thought of as including the connections of the device elements.However, it may include a range of software, hardware and firmware thatsend data to and receive data from external circuits, such as PLC's,other computers, networks, satellites, sensors, actuators, and so forth.

The run-time environment typically operates using a behavioral subsystem22, which is adapted to manage the behavior of the device elements 18.For example, responsibilities of the behavioral subsystem 22 may includethe following: place and move device elements, modify device elements,group device elements on interchangeable screens, save and restorescreen layouts, manage security, save and restore connection lists, andsupply remote access to the run-time environment 14. Here again, inpractice, such behaviors may be defined as part of the profile (i.e.,the “method” or “state engine”) of each device element.

The design-time environment 16 includes an advanced implementation ofthe behavioral subsystem 22 that facilitates direct or indirectmanipulation of the run-time environment 14, without impeding orcompromising the behavior of the run-time environment 16. That is,design and reconfiguration can be done even while an interface isoperating. The behavioral subsystem 22 extends access to the run-timeenvironment 14 via remote provision of the design-time environment 16,such as in a conventional browser. The behavioral subsystem 22 allows adesigner to interact with and change aspects of the run-time environment14 of an HMI via a remote configuration station by serving thedesign-time environment or aspects thereof to the configuration stationfrom the HMI. For example, an HMI coupled to a laptop via a network mayprovide a user with configuration capabilities by serving up a specificdesign-time environment to the laptop via the network.

Details and examples of how this may be done are provided below. Incurrent embodiments, the design-time environment may be a product ofcombining Dynamic Hypertext Markup Language (DHTML) and an Active ServerPage (ASP) server scripting to serve dynamic content to a browser. AnASP script is specially written code that includes one or more scripts(i.e., small embedded programs) that are processed on a server (e.g.,Web server) before the page is sent to a user. Typically, inconventional usage, such script prompts a server to access data from adatabase and to make a change in the database. Next, the scripttypically builds or customizes the page before sending it to therequester. As discussed below, such scripting is used in the presentframework quite differently, such as to build screen views without priorknowledge of either the functionality of device elements, or theirinterrelationships.

By facilitating changes to device elements, the design-time environmentallows the designer to make interchangeable design-time models orspecialized implementations of the behavioral subsystem 22. A specificexample of a design-time implementation of the behavioral subsystem 22includes a Web-based design-time environment, which extends access to arun-time environment on an HMI via a TCP/IP connection between the HMIand a remote device. The Web-based design-time environment facilitatesmanagement of the device elements without compromising run-timeperformance or security. In one specialized implementation thebehavioral subsystem 22 gives designers the ability to manipulateaspects of the run-time environment 14 using a Web browser that iscapable of accessing a related interface or HMI. As noted above, and asdescribed in detail below this is achieved by using a combination ofdynamic content, scripting, and configuration of the device elementproperties.

FIG. 2 is a diagrammatical representation of an exemplary control andmonitoring system 24, such as for industrial automation, implementingthe framework described above. The system includes an HMI adapted tointerface with networked components and configuration equipment. Thesystem 24 is illustrated as including an HMI 26 adapted to collaboratewith components of a process 28 through a control/monitoring device 30(e.g., a remote computer, programmable logic controller (PLC) or othercontroller). The HMI 26 may physically resemble existing hardware, suchas a panel, monitor or stand-alone device.

Collaboration between the HMI 26 and components of the process 28 may befacilitated by the use of any suitable network strategies. Indeed, anindustry standard network may be employed, such as DeviceNet, to enabledata transfer. Such networks permit the exchange of data in accordancewith a predefined protocol, and may provide power for operation ofnetworked elements. As noted above, while reference is made in thepresent discussion to networked systems and to systems incorporatingcontrollers and other equipment, the HMI 26 and programming techniquesdescribed may be equally well applied to non-networked components (e.g.,GPS displays, game displays, cell phone displays) and to networkedsystems outside the industrial automation field. For example, thearrangements and processes described below may be used in facilitiesmanagement, automotive and vehicular interfaces, computer numericcontrol (CNC) machines, point of sale (POS) systems, control interfacesfor commercial markets (e.g., elevators, entry systems), and so forth,to mention only a few.

The run-time or operation environment constructed and managed by acorresponding behavioral subsystem, is stored on and resident in the HMI26. For example, such a behavioral subsystem can be adapted to load theapplication configuration framework (e.g., 10) from a storage location,such as during initial manufacture or setup of the HMI. When loaded, thestored application framework may be adapted to create screens and locateuser interface device elements (actually images or pictorialrepresentations corresponding to the elements) in the screens. Theseapplications, screens, and user interface elements are each types ofdevice elements. As described below, the HMI 26 includes a storedapplication that dictates the layout and interaction of the deviceelements. The Web-based design-time environment, which is based on arun-time engine, is also loaded and resident on the HMI. The design-timeenvironment may be adapted to handle advanced features (e.g., securitymanagement) for both design-time and run-time environments.

The HMI may be adapted to allow a user to interact with virtually anyprocess. For example, the process may comprise a compressor station, anoil refinery, a batch operation for making food items, a mechanizedassembly line, and so forth. Accordingly, the process 28 may comprise avariety of operational components, such as electric motors, valves,actuators, sensors, or a myriad of manufacturing, processing, materialhandling and other applications. Further, the process 28 may comprisecontrol and monitoring equipment for regulating process variablesthrough automation and/or observation. The illustrated process 28comprises sensors 34 and actuators 36. The sensors 34 may comprise anynumber of devices adapted to provide information regarding processconditions. The actuators 36 may similarly include any number of devicesadapted to perform a mechanical action in response to an input signal.

As illustrated, these sensors 34 and actuators 36 are in communicationwith the control/monitoring device 30 (e.g., a PLC) and may be assigneda particular address in the control/monitoring device 30 that isaccessible by the HMI 26. The sensors 34 and actuators 36 may be indirect communication with the HMI 26. These devices may be utilized tooperate process equipment. Indeed, they may be utilized within processloops that are monitored and controlled by the control/monitoring device30 and/or the HMI 26. Such a process loop may be activated based onprocess inputs (e.g., input from a sensor 34) or direct operator inputreceived through the HMI 26.

The server software on the interface permits viewing of the developmentenvironment, and direct reconfiguration of the interface (particularlyof the device elements and their associated appearance andfunctionality) without the need for special viewing or configurationsoftware. This benefit flows from the fact that the device elements andthe design-time environment itself is resident in the HMI, and “servedup” by the HMI to a browser or other general purpose viewer on theconfiguration station. In other words, necessary support for externalcomputer workstations (e.g., laptop and desktop computers) may bereduced or eliminated. It should be noted that reference to a “browser”for viewing and modifying configuration of the interfaces is not limitedto Web browsers or to any particular browser. References to a browserare intended to be exemplary. More generally, the term “browser” isutilized herein to reference software which includes any general purposeviewer.

The HMI 26, through the programming of the device elements as describedbelow, may be thought of as including instructions for presenting one ormore screen views, and device elements executed upon interaction withthe HMI by reference to the screen views (e.g., pressing a button,touching a location of a screen, and the like). The screen views anddevice elements may be defined by any desired software or softwarepackage. For example, the screen views and device elements may be calledby or executed by an operating system 38. The device elements, asdiscussed above, in accordance with present embodiments, are objectsconforming to “.NET” or “ActiveX” standards. The operating system itselfmay be based upon any suitable platform, such as Window CE. Asreferenced herein, the device elements and tools support Web services ortechnology for transmitting data over networks (e.g., the Internet).These device elements thus follow a set of rules regarding informationsharing and are adapted for use with various scripting and programminglanguages, as described below. Such device elements enable provision ofinteractive content to outside applications such as a LAN, WAN, anintranet, an extranet, or even the World Wide Web. Accordingly, theoperating system 38 and the various device elements facilitate dynamicconfiguration of the HMI 26 through a browser by allowing configurationaccess (e.g., serving up) to the browser.

For example, such configuration access includes access for instantiationof device elements. In other words, new device elements can actually becreated and implemented from the browser. Again, it should be noted thatthe browser does not require actual functional access. Indeed, in oneembodiment, requests via the browser result in a “draw” sequence ofoperations based on data functionality and content of device elements ina container, thus allowing illustration of the device elementrepresentations and access to their configuration without actuallyserving up functional aspects. This allows for configuration via aremote workstation without necessitating technical support for theremote workstation. Such aspects are described in greater detail below.

In addition to the operating system and device elements as describedabove (and as described in greater detail below), the HMI 26 includes anapplication or application layer 40. The application, which may itselfcomprise a device element, facilitates access to and acquisition ofinformation from the various device elements of the HMI. In particular,the application 40 represents a first level in a multi-level deviceelement that can be enumerated for execution. The application 40 in apractical implementation may comprise a user application in the form ofan XML page. The user application is then interacted with by the user oroperator, as well as by the designer as described in greater detailbelow.

The screen views and device elements may be described as independentexecutable pieces of software. In a present implementation, the screenviews are defined by appropriate code written in a markup language(e.g., Hypertext Markup Language or HTML). Thus, the configuration ofgraphical interface screens for the HMI 26 may be performed without theuse of conversion programs. Further, by programming of the deviceelements, the screen views may be developed directly on the HMI 26 viaresident server software (designated as server 42) that makes theresident development environment available for remote access.Specifically, in one embodiment, representations of certain deviceelements (e.g., ActiveX controls) are served up to the browser withoutserving up the software components themselves. Because a development ordesign-time environment may be accessed via a browser, the need todownload changes to the screens and to update remote configurationsoftware applications can be eliminated.

As noted above, device elements may include functionality by which theyread from or write to specific memory or registers of memory, typicallyin other devices (but which could also be within the HMI). For example,a particular function may correspond to writing to or reading from aregister 32 of control/monitoring device 30. In a simple case, forexample, an object simply accesses a piece of data (e.g., a state of acomponent as determined by a sensor), and generates an output signal towrite a value corresponding to the state of a different networkeddevice. Much more complex functionality can, of course, be configured.In an industrial control and monitoring context, for example, suchdevice elements may emulate operation of a range of physical components,such as a momentary contact push button, a push button with delayedoutput, a switch, and so forth. Many pre-programmed device elements maybe available for use by the HMI 26. Such functional modules may beaccessible via a network, or may be resident on the HMI 26, or residenton a separate device directly linked to the HMI 26. In this way, an HMIsupplier or software supplier may provide many possible building blocksfrom which screens and complex control and monitoring functions may beprogrammed. Indeed, a library 44 of available device elements may resideon the HMI 26 to facilitate configuration of the HMI 26, as describedbelow. The screen instructions may call upon the device elements forperforming desired functions based upon operator inputs, and theseinstructions may be programmed into versions of the pre-programmedelements. For example, the operator may provide initiating inputs bytouching a location on a touch screen or depressing keys on a keyboard.Based upon the screen instructions and the device elements associatedwith the instructions (e.g., with specific locations triggering calls orexecution of pre-configured device elements) the desired functions maythen be executed. Accordingly, the operator is enabled to interact witha process, typically to change screen views, write to registers, orcommand the generation of other output or control signals. In astand-alone implementation, the interactions may simply recall or storedata, change screens, and so forth.

One or more separate interface screens may be employed, with some HMIshaving many such screens and a great number of device elements. Eachdevice element may, in turn, be uniquely programmed to consider specificinputs, perform specific functions, and generate signals for specificoutputs. A plurality of such device elements can be loaded and hosted ina single software “container” (e.g., ActiveX container) as describedbelow.

The HMI may be configured by interacting directly with a panel or screenon the HMI itself (if one is present), but in many cases configurationwill be performed from a remote configuration station 46. For example,access is provided directly to the resident library 44 and/or operatingsystem 38 and application 40 via a browser 48 or similar application. Ina present implementation, no other specialized software is required atthe configuration station 46. Indeed, the server 42 resident on the HMI26 may provide access to the device elements in library 44. By storingthe device elements in library 44 directly on the HMI 26, the risk ofversion conflicts and so forth are eliminated or reduced. Additionally,the HMI may be directly connected to the configuration station, oraccessed by reference to an IP address (Internet Protocol address)assigned to the HMI 26.

Access control schemes may be used to limit the ability to changescreens and device elements. For example, a password or user accessstatus may be required to gain such access. Further, in a presentlycontemplated embodiment, the configuration station automaticallyrecognizes the HMI or the terminal on which the HMI is resident as adevice upon being coupled to the configuration station (e.g., similar toan external memory or drive). Thus, once connected to the configurationstation, the HMI may simply be “recognized” as a device that can beaccessed (providing the configuration screen and tools described below).

Once the device elements then resident on the HMI 26 are accessible tothe configuration station 46, aspects of the HMI 26 can be modified orupdated directly on the HMI 26 via the communication link from theconfiguration station 46. For example, a user may wish to update aparticular HMI graphic to provide data, such as historical data ortrending relating to information being received from a newly installedsensor 34. Additionally, the user may find it desirable or convenient toupdate the HMI graphic for presentation of such data while in anoff-line mode (e.g., without immediately implementing the changes). Insuch a scenario, the user may link to the library 44 of available deviceelements via the configuration station 46 and use them to modify the HMIgraphic or functionality in a development environment.

It should be noted that additional device elements can be added to thelibrary 44. For example, if a trending device element is not resident onthe HMI 26, a user can download such an element to the HMI 26 from aconfiguration library 50 resident on the configuration station 46.Alternatively, a user could access the trending device element from aresource library 52 accessible via a network (e.g., the Internet),either directly to HMI 26 or through the configuration station 46. Thismay be particularly beneficial because new and improved device elementscan be downloaded to the HMI 26 individually and on a periodic basis,thus adding new functionality without necessitating the periodic releaseof new conversion programs or HMI operating systems, or run-time ordesign-time environment software. The development environment mayprovide links to such libraries. Further, in embodiments using embeddedcode (e.g., operating system, server software, device objects, etc.),because the embedded code resides on the HMI 26, version conflicts withthe embedded code may be avoided and the necessity for configurationstation software upgrades may be eliminated.

FIG. 3 is a high-level flow diagram representing interaction between anHMI and a configuration station. More detail regarding such processes isprovided below. In general, a platform for the HMI and configurationstation will include the operating system or executive software 38,application software 40, as well as any communication software, amicroprocessor, a network interface, input/output hardware, genericsoftware libraries, database management, user interface software, andthe like (not specifically represented in FIG. 3). In the illustratedembodiment, a design-time platform and a run-time platform interactwithin the HMI. The design-time platform provides views that are servedas the design-time environment 16 to a desktop personal computerplatform (e.g., running a suitable operating system, such as Windows XPor RedHat Linux) and the run-time platform cooperates with thedesign-time platform via the operating system (e.g., Windows CE, Linux).The design-time platform provides dynamic server content 54, while therun-time platform displays views on the HMI itself (if a display screenis provided on the HMI). The design-time environment 16 is displayed ina browser 48 (e.g., Web browser or other general purpose viewer).

FIG. 3 represents at a very high level how the design-time environment16 interacts with the operating system 38, application 40 and run-timeenvironment 14. The arrow 56 represents dynamic exchange of contentbetween the HMI 26 and configuration station 46. In general, interactionwith the design-time environment is the task of a designer 58 whoinitially configures the HMI screens or views, device elements, theirfunctions and interactions, or who reconfigures such software. Therun-time environment is generally interacted with by an operator 60directly at the HMI. It should be noted that while the design-timeenvironment 16 has specific needs, in a current embodiment, it dependsheavily on the operating system, application and run-time environment.The design-time environment 16 and the run-time environment 14 mayutilize certain base technologies (e.g., DHTML, HTML, HTTP, dynamicserver content, JavaScript, Web browser) to operate respectively in thedesign-time platform and run-time platform. While, in the illustratedembodiment, the run-time environment 14 and the design-time environment26 reside on separate platforms, in some embodiments they may reside onthe same platform. For example, the design-time platform and run-timeplatform may be configured as or considered a single platform.

In one embodiment of the present invention, a design-time Webimplementation is utilized. This design-time Web implementation offersthe speed and flexibility of software running on the design-timeplatform by using a Web browser (e.g., 48) with DHTML support from theHMI, as noted by the dynamic server content 54 in FIG. 3 and asdescribed below. DHTML is used to perform dynamic manipulation of Webcontent in the design-time environment 16. Further, the dynamic servercontent 54 is used in the HMI to serve dynamic Web content to thedesign-time environment 16. This dynamic client-server environmentallows the Web browser to simulate an application running on thedesign-time platform without requiring a piece of software compiled fora related processor.

Exemplary Interface Configuration

FIG. 4 is a block diagram illustrating interaction among components ofboth an HMI and a configuration station in accordance with embodimentsof the present techniques. Specifically, an HMI 26 that is in acommunicative relationship with a general purpose computer (PC) 46 viadata or content link 56. The data link 56 may comprise a direct cablelink, a network link, a wireless link, or any interconnecting circuitbetween locations for the purpose of transmitting and receiving data.For example, the data link 56 may represent, in part, the Internet.Further, both the HMI 26 and the PC 46 are illustrated as comprisingcertain exemplary components that facilitate operation and communicationin accordance with embodiments of the present techniques.

The HMI 26 may comprise a configurable tool built around an HMImicroprocessor 62. The HMI 26 may be adapted to interface with anindustrial hardware interface such as a programmable logic controller(PLC) 94. While the HMI 26 may comprise many different parts andcomponents, certain exemplary components are presently illustrated todemonstrate aspects in accordance with embodiments of the presenttechniques. Specifically, in addition to the processor 62, theillustrated embodiment includes a display module 64 (e.g., a graphicalcomponent or physical display screen), a display/input interface module66, an input module 68 (e.g., keypad or touch-screen), a communicationmodule 70 (e.g., TCP/IP component), and memory 72. In accordance withthe present techniques, the memory module 72 may store computer programsand components such as a markup language page 74 (e.g., HTML page), acontrol object library 44, and embedded code defining a configurationapplication 76.

The markup language page 74 may include any document created in a markuplanguage that can be displayed. Multiple pages, such as page 74, may bestored in memory 72 for utilization in interfacing with a system orprocess. As discussed above, each such page will typically comprisescreen instructions 78 and links 80 to pre-programmed functional modulesor device elements. For example, the links 80 may cooperate with certaindevice elements 18 to facilitate display of system parameters and/orcontrol of a related system or process. The HMI 26 may provide access tosuch pages and configuration of such pages using a server program 42(e.g., an ASP server) stored in memory 72. Additionally, the HMI 26 oran external configuration station (e.g., PC 46) may utilize such pagesby employing a standard browser program 48. In accordance withembodiments of the present techniques, software components related tothe page 74 facilitate a configurable development environment. In oneembodiment, the development environment itself is configurable.Accordingly, as described below, fixed components of the developmentenvironment (e.g., a banner) can be changed for aesthetic or functionalpurposes. For example, a customer purchasing an HMI in accordance withembodiments of the present technique can change a banner in thedevelopment environment to display a customer logo rather than amanufacturer logo. A user can make changes to the developmentenvironment in the same way changes are made to object properties.

The device elements 18 may comprise modular control strategies andgraphical components that enable system configuration and operation. Forexample, the device elements 18 may include modules for configuring oneor more field devices (e.g., inputs and outputs) and related controllogic (e.g., expressions). Indeed, these device elements 18 may beadapted to provide reusable configurations for process equipment,sensors, actuators, control loops and so forth. As discussed above, inaccordance with embodiments of the present techniques, available deviceelements may reside in a library stored on the memory module 72. Eachdevice element 18 in accordance with present techniques may include aunique control tag, a data history, a display definition, and a controlstrategy (i.e. stat engine). Further, each device elements 18 may be aseparate module, enabling operation, debugging, and transfer ofindividual elements 18 without affecting other elements. In manysettings, and particularly in industrial automation contexts, “families”of such elements may be pre-defined, such as for various types of pushbuttons, trending modules, and so forth.

As discussed above, the application 76 may cooperate with separateserver application 42 that is stored on the HMI to provide access toconfiguration of the HMI 26. Alternatively, the application 76 mayitself comprise a server module to perform such a function. A user mayremotely configure the HMI 26 from the PC 46 using a browser 48. Theapplication 76 may comprise the configured device elements thatconfigure the markup language page 74. For example, the application 76may allow a user to configure the page 74 in a development environmentfor use as a graphical interface in the HMI 26. Once configured, thepage 74 may be saved as a file, and implemented in an operation mode ofthe HMI 26, where the page 74 may be utilized as an operable graphicalinterface. Each device element 18 may be an independent executable pieceof software that can communicate with other elements to perform complexfunctions.

The PC 46, much like the HMI 26, may comprise a general purpose toolbuilt around a microprocessor 82. The illustrated PC 46 is adapted forinterface with the HMI 26 through data link 56 to facilitateconfiguration of the HMI 26. While the PC 46 may comprise many differentparts and components, certain exemplary components are presentlyillustrated to demonstrate aspects in accordance with embodiments of thepresent techniques. Specifically, in addition to the processor 82, theillustrated embodiment includes a display module 84 (e.g., a graphicalcomponent or physical display screen), a display/input interface module86, an input module 88 (e.g., keyboard), a communication module 90(e.g., TCP/IP component), and a memory 92. In accordance with thepresent techniques, the memory module 92 may store computer programs andcomponents such as the browser application 48. In accordance with someembodiments, the browser application 48 may be adapted to display amarkup language page, such as page 74. Indeed, the browser 48 may be theequivalent to the browser 48 of the HMI.

FIG. 5 illustrates certain of the functional components contained in apresent embodiment of an HMI 26 built upon the overall structuresdescribed above. In particular, FIG. 5 illustrates server software 42contained generally in the design-time environment or engine 16. Asdescribed more fully below, the server software 42 permits dynamiccontent to be provided to a browser 46 that will be displayed in theconfiguration station. The server software 42 also facilitatesinteraction with the run-time environment or engine 14 and with thevarious device elements 18 configured within and stored within the HMI.Moreover, within the HMI is software, also described below, whichfacilitates interaction with display hardware 64 of the HMI itself,storage hardware or memory 72 of the HMI, communications hardware 70 ofthe HMI, input hardware 68 of the HMI, and generally with systemcomponents 94 which will be remote from but interconnected with the HMI.

The server software 42 generally includes an HTTP server component 96,an ASP extensions component 98, a Java script component 100 and a VBscript component 102. As will be appreciated by those skilled in theart, in a present implementation, the HTML server service component 96receives and transmits data by means of a TCP/IP stack 104 which isexchanged with the browser application contained within theconfiguration station. The HTTP server module 96 itself pre-processesportions of code received via the TCP/IP stack 104 based upon codeextensions in the form of “ASP” extensions. While various otheralternative scripting may be employed, and a present implementation ASPextensions are used to convey to module 98 that scripting functions areto be performed. The ASP extensions module 98, then, handles the ASPcontent as described below. Various alternatives to such ASP scriptingmight include Java service pages (.JSP scripting), CGI scripting, APIscripting, and so forth. The Java script module 100 and the Vb scriptmodule 102 are provided as examples of interpreters for the server sidescripting.

As will be appreciated by those skilled in the art, various existingapproaches have been used for scripting, including using ASP extensions.Such applications typically involve modifications to a database. Thatis, in order processing software and applications, such extensions maybe used to alter order status, inventory levels, and so forth. In thepresent application, such extensions are used, and more generally suchserver side scripting is used entirely differently. Here the scriptingis used to access device elements, enumerate such elements to determinetheir identifies and properties, compile views that can be provided tothe designer, and perform all such functions without prior knowledge ofthe application or device elements themselves, and also without servingthe actual code or device elements themselves. The server software 42thus provides a highly flexible platform, particularly in conjunctionwith the access module 106 described below, that can be used with anyunderlying configuration or device elements to provide a simple anduser-friendly design-time environment served to a general purposebrowser.

Access module 106 is itself a device element. This module runs in theweb services processing space (See, services module 108 in FIG. 5). Ingeneral, the access module 106 is called by the server module 42 toprocess code flagged by ASP extensions. The access module 106, then,accesses various device elements which are configured within the HMI asdescribed more fully below. As illustrated in FIG. 5, such deviceelements may include push buttons, gauges, trend engines, and so forth.In a more general context, such device elements may include anygraphical elements used for interacting with an HMI or any other displaythat may or may not communicate with a process. As described above, suchdevice elements may include elements only of the display which is astand-alone device. In certain environments, for example, the HMI may bea communications device, such as a cell phone, a location device, suchas a GPS receiver, or any other human interface device. It should alsobe noted that the device elements 18 need not all have a viewablecontent component. That is, many device elements may be configured thatare not represented in either the browser of the design-time environmentor the viewable screen of the HMI itself. Such device elements mayperform computations, control functions, locating functions, in variousprocessing that is simply not viewed by the user.

The services module 108 and the run-time engine 14 communicate with adatabase services module 110 and with one another. As described morefully below, the services module 108 loads and maintains services (e.g.,DLL's), such as a stack and server software as a single process space.The run-time engine or environment 14 itself may include a range ofsoftware components or device elements, such as a shared memory manager,a development system manager, a display manager, a project manager, andso forth. The run-time engine 14 interfaces with the device elements 18and with various other software, which also may be configured as deviceelements. Among the noted software components, is a display manager 112that interacts with an OS/GDI subsystem 120 and a suitable driver 122 toprovide viewable content to the display hardware 64. Similarly, run-timeengine 14 interacts with a storage manager 114 and suitable driver 124to write and read data from storage hardware 72 within the HMI. Therun-time engine 14 to also interacts with a controller/PLC accesscontrol module 116 and suitable driver 126 to provide access duringinteraction with any remote controllers or PLC's, particularly inautomation context. Finally, the run-time engine 14 interacts with aninput manager 118 and suitable driver 128 for overseeing the inputs frominput hardware 68, such as actual or virtual push buttons, a mouse, akeyboard, and so forth. As also noted in FIG. 5, a system module 130 caninteract with the server software 42 to provide direct access through asuitable drive 132 to remote system hardware 94.

FIG. 6 is a block diagram generally representing a configurableinterface and its interaction with a browser in accordance withembodiments of the present technique. The configurable interface isgenerally referred to by reference number 26. The configurable interface26 is adapted to communicate with browser 48. For example, a “paint”module 144 resident on the configurable interface 26 may signal thebrowser 48 to “repaint” a graphic display presented by the browser 48based on changes to certain visual properties residing in softwarecomponents of the configurable interface.

Specifically, FIG. 6 illustrates the configurable interface 26 includinga device element 18 that is adapted to provide a functional module orportion 136 for configuration in the designations environment. Thedevice element 18 includes a property 134, such as relating to apictorial view of the functional module 136. The configurable interface26 also includes a query receiver 138, an actual frame buffer 140, avirtual frame buffer 142, a display 64, and a server application 42 asdescribed above.

Embodiments of the present technique relate to abstracted displaybuilding based on modification to software components via queries.Queries are utilized in accordance with embodiments of the presentinvention to transfer configuration input to software components in theconfigurable interface from a browser application on the configurationstation. In one embodiment, communication is facilitated between theconfigurable interface and the configuration station by uniqueutilization of a server, such as an ASP (Active Server Pages) server asmentioned above. Accordingly, modifications may be made to an HMI bycomposing new or modifying existing screen instructions, and by adding,removing, or modifying device elements called or executed in response touser inputs made by reference to the displayed HMI screens. A design canmanipulate graphical representations on a browser to change actualcontrol objects on the HMI. Changes to graphical representations on thebrowser are submitted as a query to the HMI, which receives the queryand adjusts aspects of the relevant device elements accordingly. Forexample, a color property of a graphic feature may be altered throughthe browser resulting in a query that operates to instruct a relevantfunctional module 136 of a device element 18 to change its colorproperty, thus changing the color of the corresponding representation onthe HMI and within the design-time environment.

In the illustrated embodiment, and as described in greater detail below,the query receiver 138 is adapted to receive queries from the browser 48and then transmit the query or related information to the device element18 for implementation (through the intermediaries of the server softwareand access module described above). For example, the browser 48 may senda request directed to changing a graphical characteristic (e.g., color)of the functional module 136 (e.g., a virtual pushbutton) as a query.The query receiver 138 receives the query and transmits it to thesoftware component 18 for implementation. Once the request istransmitted, the software component 18 implements the query bymanipulating the property 134 in accordance with the query. For example,a designer may change a color of a virtual gauge being represented onthe browser 48 from red to blue by manipulating the representation onthe browser 48. By thus manipulating the representation on the browser48, the designer initiates the query that eventually results in changingthe property 134 from a value relating to the color red to a valuerelating to the color blue.

In accordance with embodiments of the present technique, the property134 will be changed in the actual device element 18 and browserrepresentations. Specifically, in one embodiment, a query relating tonew property information is submitted through the browser bymanipulating representations of particular software component propertieson the browser. This new property information is submitted as a query tothe configurable interface 26 and related changes are implemented in thedevice element 18. The device element 18 then responds by submitting acommunication describing the newly implemented property information tothe browser 48, which displays revised property representations. Thisprovides a real-time view of changes in configuration while allowingconfiguration via the browser 48. In one embodiment, changes are made bydirectly accessing system memory. However, such changes may be made tothe actual frame buffer 140 and/or the virtual frame buffer 142 inparallel with changes to memory in the configurable interface 26. Thus,as described below, the design-time environment may provide onerepresentation (e.g., in the browser) of the changes, while the HMIdisplay itself also reflects the change in parallel via the run-timeenvironment or engine.

The device elements available to configure the configurable interface 26(e.g., HMI 26) and/or related embedded code are accessed from theconfigurable interface 26 by a configuration station (e.g., 46) duringconfiguration. Accordingly, concerns relating to revision and capabilitydifferences between the related software components (e.g., operatingsystem, device elements, drivers, etc.) and the configurable interface26 are minimal. Functional aspects of the configuration are notnecessarily transferred between the configurable interface 26 and theconfiguration station. As discussed above, in accordance withembodiments of the present techniques, configuration of the configurableinterface 26 is achieved through queries submitted via the browser 48.Indeed, the configuration station and the configurable interface 26 donot even need to have, and typically will not have the same operatingsystem.

Dynamic Interface Configuration and Use

FIG. 7 is a flow diagram generally representing a configurable interfaceand its interaction with a browser in accordance with embodiments of thepresent technique. The configurable interface, which is generallyreferred to as HMI 26, includes device elements 18 and is adapted tointeract with a browser 48. As illustrated, this interaction between theHMI 26 and the browser 48 facilitates dynamic representation ofconfiguration of the device elements 18, which are resident on the HMI26. Further, the interaction includes enumeration by an enumerationcomponent 146 of the HMI 26 (by interaction of the HMI components asdescribed below). It should be noted that the browser 48 may be residenton a remote configuration station 46 (e.g., a laptop computer) inaccordance with present embodiments. It should also be noted, however,that configuration may be provided directly on the HMI through the sametechniques and architecture described herein.

In the illustrated embodiment, the browser 48 communicates with the HMI26 by sending queries and receiving responses. For example, in theillustrated embodiment, the browser 48 initiates communication bysending an identification query, as illustrated by block 148, to the HMI26 requesting specific identity information for the HMI 26. Afterreceiving the query 148, the HMI 26 processes the request and respondswith identification data (e.g., “Model 200 Panel View”), as illustratedby block 150. Additional queries are then used to enumerate levels ofthe application and device elements on the HMI 26 including enumeratingthe structure of device elements 18. Indeed, the HMI 26 may have astructured content, such as a tree structure (i.e., a set of linkednodes, each having zero or more child nodes), that is readilyenumerated. For example, block 152 represents a query requestingenumeration of a next level beneath the identity of the HMI 26. Further,block 154 represents a response corresponding to the query in block 152indicating what applications are present on the HMI 26. This query andresponse procedure continues, in accordance with embodiments of thepresent technique, until display characteristics of the softwarecomponents are enumerated, as illustrated by block 156. In oneembodiment, the query and response procedure continues until an entiretree structure of elements resident on the HMI 26 has been enumerated.It should be noted that much or all of such enumeration may betransparent to the designer, who will be interested in one or moreproperties of a device element at a time.

In one embodiment of the present technique, once the structure of theHMI 26 has been enumerated, a view is configured for display via thebrowser 48. For example, a graphic component, such as a JointPhotographic Experts Group or JPEG image may be constructed basedenumerated properties and served to the browser 48 as the view or as aportion of the view. Such a JPEG image may correspond to a particulardevice element. For example, the JPEG image may be representative ofparticular enumerated display characteristics for a device element.Specifically, the JPEG image may represent a virtual pushbutton orgauge. Further, configuration tools may be served to the browser.Indeed, the view itself may act as a tool for manipulatingcharacteristics of the related device element. Also, for example, aseparate display palette may be served to the browser to facilitatereconfiguration of the color of a particular device element.

FIG. 8 is a flow diagram illustrating manipulation of a graphicalfeature relating to a device element in a design-time environment inaccordance with embodiments of the present techniques. While FIG. 8illustrates a single variable manipulation, multiple graphical featuresand properties can be manipulated in the same way. The flow diagramincludes interactions illustrated by relationships between a display 164(e.g., a screen for browser display), a property editor 182, and an HMI26. Specifically, the diagram illustrates exemplary activitiesassociated with moving a device element image 168 represented on thedisplay 164 using a browser 48.

The design-time environment represented by the configuration screen ordisplay 164 includes static content 166 and dynamic content. The dynamiccontent includes images corresponding to any displayed or representeddevice elements 168 (e.g., virtual on/off button, gauge). In oneembodiment of the present techniques, the image is specified by an imagetag in HTML and is part of a JPEG file created by the HMI as describedbelow. The static content 166 may be created by the ASP server or it maypreexist in an HTML file. It should be noted that, in some embodiments,designated designers only can edit the static content 166.

In the representation of FIG. 8, the device element representations 168are contained within a view container 158. As will be appreciated bythose skilled in the art, a container generally defines a portion of aprocessing space in which certain device elements are opened and readyfor use. The container 158 may thus correspond to a first view containerthat includes only the elements viewable within the current screen. Asdiscussed above, many such screens may be provided in the HMI. Otherscreens, such as alternative control or interface screens may beprovided in other view containers, such as a container 160. In general,to speed the operation (e.g., changing between screen views) of the HMI,such view containers are predefined and associated with one another bydefinition of the individual device elements with which they are eitherassociated or within which representations of the device elements areprovided. A global container 162 is defined that include all of thedevice elements necessary for the various view containers, as well asother elements that may not be represented in any view container. Asillustrated in FIG. 8, therefore, view container 158 includes thevirtual button 168 which performs a “jog” function and is manifested bya representation in a first screen. New container 160 includes severalcomponents, such as a “start” button 172, a “stop” button 174, a virtualgage 176 and a digital readout 178. The global container 162, then, willinclude all of these device elements for the various view containers, aswell as any device elements 180 that are required for operation of theviewable device elements but that are not themselves viewable. Suchdevice elements may include elements that perform computations,trending, communications, and a wide range of other functions.

In accordance with aspects of the present technique, all device elementsthat are needed for the various views are opened during operation of theHMI and remain open in a single global container 162. However, utilizingaspects of current technologies, known as “tear-offs” any deviceelements that are not required for viewing or operation of a currentview (i.e., a view currently displayed on the HMI or configurationstation view) are reduced in size to reduce the memory requirements,processing requirements, and to facilitate operation of the HMI. The“torn-off” device elements nevertheless remain open and active such thatchange in between screen views is extremely rapid and efficient frommemory utilization and processing standpoints.

As illustrated by arrow 170, in an exemplary change or configurationoperation, button 168 is moved from one location to another within thedisplay 164. For example, a system in accordance with embodiments of thepresent technique may include an input device, such as a mouse, thatfacilitates designer manipulation of the image 168. Client script fromthe display 164 or some other source running in the browser 48 may beused to monitor device events in the display 164. Specifically, forexample, when a mouse press event (e.g., clicking a mouse button) isdetected over an image (e.g., image 168) that is tagged as an image andthat represents a device element representation, the client scriptbegins tracking the movement and repositioning the image 168 relative tothe updated mouse position. In one embodiment, the client scriptcontinues to track the mouse movements as long as the mouse button is ina depressed position. When the mouse button in released, a call ispassed to a property editor 182 indicating that a device elementrepresentation move has been completed. In an alternative embodiment,multiple button presses may be used to initiate the call. For example,depressing the mouse button once may initiate tracking and pressing themouse button a second time may indicate that the move is complete.

Upon receiving the call, the property editor 182 reloads itself asdescribed more fully with reference to FIG.s 10 and 11. In oneembodiment, this reloading includes passing a move command objectpointer, and positional data via a query string from the browser 48 toserver 96 (e.g., HTTP server) that is resident on the HMI 26. Forexample, http://10.90.77.11\MvPropertyASP@M001200200 is an exemplaryreload string that may be passed to the server 96. The server 96cooperates with ASP server 98 including a dynamic-link library (DLL) 184to receive and respond to queries. The DLL 184 allows for storage ofexecutable routines as separate files, which can be loaded when neededor referenced by a program. In the example set forth above, uponreceiving the call, the page is reloaded by the ASP server 98 and thequery string is initially parsed resulting in evaluation of the movecommand. Server side script then invokes the access module 96 to accessthe device element 18 related to the image 168 and to update itslocation property. The new property information is then updated on thepage and the page is passed to the browser 48.

In one embodiment of the present techniques, user prompting via thedisplay 164, such as the previously described mouse release event of theimage 168, causes the reload of the property editor 182 alone. Forexample, in one embodiment, the display 164 is not reloaded based on themouse release event. Indeed, in accordance with embodiments of thepresent techniques, code may actually use functionality that will notrequire the entire property page to reload.

FIG. 9 is a sequence diagram for certain operations performed on the HMIor rather configured as described above. In the illustration of FIG. 9,various persons and components generally are represented with operationsperformed between these entities being shown. The entities involvedinclude a designer 58 and an operator 60 as well as a design timeenvironment and its components 16, the operating system 38, the run-timeenvironment and its components 14, and the resident application of theHMI 40. In the illustration of FIG. 9, a first series of events aredesigned to display one or more screens programmed into the HMI for anoperator. This sequence, identified generally by reference numeral 186in FIG. 9, is performed when an operator desires to use the HMI. As afirst step, the operator powers up the HMI as indicated by step 188.Powering up the HMI activates the operating system 38 which loads therun-time components as indicated by step 190. Loading the run-timecomponents includes opening and executing all device elements that arerequired for the various screen views accessible and viewable on theHMI, as well as any device elements that do not include viewableproperties. Upon loading the run-time components, the run-timeenvironment loads the application as indicated at step 192. Loading theapplication instantiates all device elements required for the variousviews. As noted above, only the currently viewed screen elements, andany device elements required for those elements are fully opened, withother elements being executed in the global container, but torn off toimprove memory utilization and processing speed. At step 194, then, thescreen views as defined by the run-time environment and application aretransmitted to the HMI display for viewing by the operator.

Also represented in FIG. 9 is a sequence corresponding to interaction byan operator with the HMI. In general, this sequence, designatedgenerally by reference numeral 196, is initiated by the operatorinteracting with the interface as indicated at step 198. Step 198 maybe, in practice, initiated by depressing a virtual actual button,touching a location on a touch screen, or inputting information by anyother means, such as by a control device, mouse, laptop computer, orotherwise. The operating system 38 detects the input event and informsthe run-time environment as indicated at step 200. As a result, therun-time engine informs the application 40 of the input events, and theapplication, by interacting and with an interaction between activedevice elements executes any required actions as indicated by referencenumeral 204. It should be noted that such actions are generally definedby the state engine of one or more device elements. The state engine ofeach individual device element may, for example, call for reading avalue from a particular register via a network, making a particularcalculation, executing trending, updating a view based upon a registervalue, outputting a value to a device or register, and so forth. At step206, then, the application requests a screen update from the run-timeengine 14. The screen update will, in many cases, choose the appearanceof the representation of a device element based upon a change in state.Upon updating of the screen, the displayable view is updated andtransmitted back to the display device for viewing by the operator, asindicated by step 208. Thus, the terminal screen will visually indicatethe response to the operator interaction.

It should be noted that, as described more fully below, among the manyoperations that can be performed by the device elements at step 204,such as color changes, sending and receiving values to externalregisters, and so forth, various direct connections may be made betweendevice elements that greatly facilitate the overall systemfunctionality. For example, a “connection” may be defined between two ormore elements such that the receipt of data by one element causes theimmediate transfer of the data to a different element. Thus, elementscan transmit data immediately among themselves without processing thedata by such connections. The operations performed by each element uponreceipt of the data are then defined by the programming of the function(or “method”) of the state engine of the receiving device element. Thus,as described more fully below, device elements can be caused to mirroror mimic functions of one another (e.g., to provide similar elementsviewable at different locations without rewriting redundant code), orentirely different operations can be performed based upon data ofinterest to multiple device elements.

FIG. 10 represents a sequence of events between the same entitiesdemonstrated in FIG. 9, but for building and displaying dynamic contentfor configuring or reconfiguring the HMI. The process illustrated inFIG. 10 begins at step 212 where the designer logs into the HMI. Thisoperation may be performed by accessing the HMI via a general purposebrowser, such as by typing in an IP address for the HMI in a locationwindow. Various types of access control may also be performed at step212, such as to limit access to all or part of the configurationfunctionalities to one or more types of level of designer. For example,initial configuration of the HMI may be performed at a factory, withcertain adaptations or user preferences being configurable by access, ina more limited manner, to the device elements as described below. Atstep 214 the design time engine requests an update from the HTP server.In the terms of the components illustrated in FIG. 5, the request is ina form of a request including an ASP extension transmitted via theTCP/IP stack 104 to the server module 42. At step 216, then, theoperating system requests screen updates from the run-time engine. Therun-time engine acquires the screen updates by querying device elementsfor “snap-shots” as indicated at step 214. Step 216 includes enumerationof the various device elements necessary for the particular screenupdate, and is performed by calling upon the access module 106 shown inFIG. 5 which communicates with the particular device elements of theviewed screen. At step 218, then, the active screen elements are drawnto a memory space as to display the images corresponding to the activeelements. At step 220 these “snap-shots” are corrected and converted toJPEG image elements, or to a binary format.

Based upon the image requirements for the various active device elementsneeded for the view to be presented to the designer, dynamic content isbuilt for viewing as indicated at step 222. Essentially, building of thedynamic content involves determining where certain snap-shots are to belocated in a view, and writing HTML tags with the JPEG image data andthe corresponding locations for all active panel elements (i.e., deviceelements having a representation viewable in the screen to beconsidered). It should also be noted that the building of the dynamiccontent at step 222 is done in a memory space that is separate andparallel to the memory space used to actually present data to anoperator on the HMI. Thus, through the steps of FIG. 10 dynamic contentis built and presented without any prior knowledge of the underlyingfunctionality or structure of the device elements or theirinterconnections. At step 224 the dynamic content is posted to a displayframe. Exemplary illustrations of such display frames are provided inthe figures below. At step 226 property information, as enumerated atsteps 216 and 218 is updated for presentation in a property frame asdescribed more fully below. At step 228 property update information isrequested based upon the property information update, a request forproperty update is generated by the operating system 38 and transmittedto the run-time engine 14 as indicated at step 230, essentially, step230 is similar to step 216, with both steps generally includingadditional levels of enumeration of the device elements. Such multiplelevels of enumeration are also described above with reference to FIG. 7.At step 232, then, each individual device element is queried for itsproperty information that will be displayed in the property frame. Manysuch levels of enumeration may be performed, particularly to determineconfiguration of applications, elements, properties, and with each levelitself being capable of having additional device elements and propertiesassociated therewith. At step 234 the property information is collected,such as in the form of an HTML page table.

At step 236, then, the dynamic content of the property frame is builtagain, in a manner similar to the functions performed at step 222discussed above. The dynamic content is then again posted as indicatedat step 238, and ultimately the dynamic content is displayed asindicated at step 240. In terms of the components illustrated in FIG. 5and discussed above, such functions are performed by interaction of theserver module 42 with the run-time engine 14 and access module 106 whichinstantiate and enumerate the various device elements to determine theirvarious properties. In all of these operations, again, the static anddynamic content is served to the designer, with the content beingwritten to a memory space separate from the frame buffer used for theHMI display itself.

FIG. 11 represents a similar sequence of steps for interaction between adesigner and HMI but for changing one or more aspects of a deviceelement. In the sequence of FIG. 11, a designer first makes a change toa design element as indicated at reference numeral 242. Such a changemay, for example, correspond to a move event such as for movingrepresentation 168 illustrated in FIG. 8 to a new location as indicatedby arrow 170 in FIG. 8. At step 244 the design-time engine 16 formulatesa request for a change that is transmitted to the operating system 38.Such request, as before, will typically be in the form of a querystring, such as for invoking scripting by reference to an ASP extension.At step 246, the requested change is transmitted to the run-time engine.At step 248, the request is made to the application 40. In response tothe request, the application, which will have enumerated theinstantiated device elements as before, executes a change to thecorresponding property as indicated by reference numeral 250. The changein the property actually changes the configuration of the device elementaffected by the change. More than one such device element may beaffected, such as both on-screen representations and device elementswhich are open in the global container but do not correspond to arepresentation on the viewable screen.

At step 252 the terminal display (i.e., the HMI display) is updated toreflect the change. It should be noted that updating of the display atstep 252 affectively is performed by the run-time engine 14 andapplication working in parallel through the display manager and othercomponents illustrated generally in FIG. 5 and discussed above. Thus,changes in the view on the device itself and as dynamic content in thedesign-time environment displayed in the browser of the configurationstation are represented in parallel, without directly affecting therun-time utilization made by the operator. Again, such parallel buildingof the views is performed in quite different manners, that is, theupdated display provided to the operator at step 252 is performedthrough the actual run-time engine 14, whereas in the steps to follow,representation of the change provided in the design-time environment iswithout direct reference to the actual functionality underlyingoperation of the design elements, but is merely a representation ofimages provided through the dynamic content.

At step 254, the updated property information is collected as in step234 of FIG. 10 and dynamic content is built including representation ofthe change as indicated at step 256, which is generally identical tostep 236 above with reference to FIG. 10. At step 258 the dynamiccontent is again posted as it was at step 238 in FIG. 10, and thedynamic content is again displayed at step 260. At this point theconfiguration of the device element is complete.

EXEMPLARY EMBODIMENTS

FIG. 12 is a representation of an exemplary configuration screen that ispart of a remotely accessible design environment in accordance withembodiments of the present technique. Specifically, the illustratedembodiment represents a design environment, as viewed through a Webbrowser, including a frameset with four major sections. In oneembodiment of the present technique, a frame appears in a Web browser asa scrollable window in which pages can be displayed.

The configuration screen may be generally referred to by referencenumeral 262. As illustrated, the configuration screen 262 comprisesexemplary sub-screens (i.e., frames) that allow configuration of amarkup language page for utilization as an HMI graphical interfacescreen. Specifically, the configuration screen 262 includes thefollowing frames: a top frame 264, a display frame 266, a toolbar frame268, and a property frame 270. The top frame 264 is adapted to present alogo and/or banner that are editable by designated designers. Thedisplay frame 266 is adapted to facilitate management of selection,positioning, and sizing of device elements in a current view. Theproperty frame 270 is adapted for editing properties of selected designelements, applications, and views. The toolbar frame 268 is adapted forselecting/adding/removing design elements and/or views, managingconnections, loading/saving applications, invoking test scripts, and soforth. While other screens and sub-screens may be employed, the presentrepresentation illustrates only certain exemplary aspects in accordancewith present techniques. It should be noted that these screens may beaccessed in accordance with the present techniques from a remoteconfiguration station using a standard Web browser.

It should be noted that although “frames” are illustrated and discussedherein for display of device element visual representations, and fordisplay of device element properties, in practice any suitable displayarea, space or technique may be used for providing these to the designeror user. For example, as will be appreciated by those skilled in theart, “frames” are generally considered to be separate browsers orbrowser sections. Alternatively, the static and dynamic content may beprovided in a single browser or browser segment. Moreover, such data andindicia may be included in separate browsers or screens, or in drop-downmenus, or any other screen device.

The illustrated embodiment relates to accessing and displaying certainpages in each of the four major sections or frames. For example, in oneembodiment of the present technique, a remote browser accesses an HMIand loads a default page having a “.htm” extension (e.g., default.htm)whereupon the browser is instantly re-routed to a default page having an“ASP” extension (e.g., defaultASP). The “ASP” extension instructs anHTTP server relating to the browser to load and process the page as ASPcontent as described above. The “ASP” file (e.g., default.asp) includesstored script, which relates to global functionality. In one embodimentof the present technique, the script creates a base for the deviceelement corresponding to the access module 106 described above. Theglobal functionality is adapted to be called by child pages that areloaded into a frameset, the frameset having been created by the “ASP”file. For example, a particular “ASP” file (e.g., default.asp) can bethe parent frameset and can be accessed by a child frame. The displayframe 266, the toolbar frame 268, and the property editor frame 270 arepages loaded into each separate frame.

In one embodiment of the present techniques and as described above, whenthe property frame 270 loads, the server software uses the access module106 to query an active or selected device element (e.g., a selectedvirtual button) and then causes enumeration or properties of the activedevice elements. These active device elements can be applications,views, system elements, control elements, and so forth. In oneembodiment, when the display frame 266 loads, it is loaded as ASPcontent and a script section of the display frame 266 queries theinternal access module for current view information and instructs theview to draw images of all design elements of the current view andoutput them as JPEG files written to a virtual frame buffer or framememory as described above. The display ASP then builds HTML tags linkedto the JPEG files and adds positional data that is also queried from thecontrol elements via the access module, also as described above. In oneembodiment, the toolbar frame 268 uses the access module to manage itsfunctionality.

The display 266 may include an HTML document creation screen thatutilizes screen instructions and links to provide an operable HTML page.However, in some embodiments, the screen instructions are in a scriptinglanguage. The screen instructions may be programmed to facilitatenavigation through various screens (e.g., HTML pages), programs, andfunctions corresponding to various different user inputs (e.g., inputfrom a mouse). The links may reference and incorporate device elementsadapted to facilitate interfacing of the HTML page with externalinput/output components. Indeed, a device element may be linked with anHTML page to facilitate an interface between an HMI and certain processcomponents, where the HMI utilizes the HTML page as an operatorinterface screen. For example, in accordance with present techniques, bydragging-and-dropping a process device element icon (e.g., “gauge” icon272) from a device element menu 274 in the toolbar frame 268 to thedisplay frame 266, a device element may be incorporated graphically intodisplay frame 266. Such a procedure may not only form a graphic 276 butit may also establish a specific design element for facilitating aninterface between an HMI and a process. Further, the design element mayfacilitate configuration of its properties from a remote station via abrowser (e.g., its representation, its function or “method”, its stateengine operability, its connections, and all such properties of lowerlevels of the device elements which are themselves device elements). Itshould be noted that the toolbar frame 268 facilitates manipulation ofthe display frame 266 with various functions (e.g., functional buttons278) in addition to the device element menu 274.

Once a graphic, such as graphic 276, is properly located on the pagebeing developed, the property frame 270 may become available forconfiguration in accordance with the present techniques. The illustratedproperty editor frame 270 relates to the graphic 276 and othercorresponding aspects of the related device element. Such sub-screensmay enable a user to define certain properties of related deviceelements. Indeed, the property frame 270 may enable a user to associatea device element related to the property frame 270 (including thecorresponding graphic 276) with an input/output address (e.g., an I/Oaddress on a PLC). For example, a designer may associate a particularbutton with a register 32 on the control/monitoring device 30illustrated by FIG. 2. Further, in accordance with present techniques,the property frame 270 may facilitate the incorporation of a tag orlabel (for identification of the device element), a physical address(for designating the location of related sensors and/or actuators), adynamic visual component (e.g., logic to change graphic colors based oncertain inputs), operational logic, and so forth. For example, a usermay utilize the property frame 270 to link a device element including arepresentative graphic (e.g., a compressor graphic) to an I/O address ina PLC communicating with a status sensor. For example, if the equipmentis running, the graphic may be green. Alternatively, if the equipment isdown, the graphic may be red. Additionally, logic (i.e., a “method” orfunction of the state engine, or a connection) in the related deviceelement may send data to an I/O address on a PLC that is connected to anactuator, requesting that the actuator be energized based on the statusof the equipment or other feedback.

It should be noted that an extremely useful aspect of both thedesign-time environment and the run-time environment is that the staticcontent may be adapted to provide a desired “look and feel” to one orall of the screen views. For example, a supplier, reseller or originalequipment manufacturer may desire to acquire an interface device from acommon manufacturer along with the basic configuration software,run-time engine, design-time engine, and so forth. The device elementsthemselves may be configured to suit the designer or original equipmentmanufacturer. Similarly, the static content may be “relegendable” so asto permit the overall look or certain aspects of the look of theinterface to be changed as an indication of the preferences of themanufacturer. Such features may include color schemes, banners, and soforth, including indicia or logos of the manufacturer. The relegendablecontent may be simply stored on the interface device as bitmap files,JPEG images, HTML stylesheets, and so forth. When a change in therelegendable static content is desired, then, the file from which suchcontent is drawn may be simply replaced. The dynamic content is thendisplayed in or adjacent to the relegendable content, providing aplatform for marketing or designation of a source of origin.

FIG. 13 is another exemplary representation of a configuration screen inaccordance with present embodiments. Again, it should be noted that thisscreen may be remotely accessed. Specifically, FIG. 13 illustrates abrowser development view 280 that may be accessed through a browser 282from a remote station. Indeed, in accordance with present embodiments,this development view 280 may be accessed much like any other web page,from a computer that is linked (e.g., via the Internet) to an HMI. Forexample, a user having appropriate access status may simply type anaddress into an address window 284 of the browser 282 and gain access toconfiguration of the HMI via the development view 280.

It should be noted that the illustrated embodiment of the browserdevelopment view 280 includes a development environment 286 that isrepresentative of a physical HMI panel, including buttons 288 and a workscreen 290. Indeed, to facilitate operational familiarity, thedevelopment environment 286 may include graphics and software functionsthat emulate configuration directly on the physical HMI. For example, auser may be able to virtually push the buttons 288 and manipulate thework screen 290 in a fashion similar to configuring the HMI directly.Accordingly, an operator that is accustomed to programming an HMIdirectly on the HMI in the field, may immediately be familiar with thebrowser development environment 286 because the appearance andfunctionality mimic an actual HMI.

In addition to the representation of the actual HMI, the developmentenvironment 286 may comprise an object assembly tool 292, an updatenotice banner 294, and an object properties view 296. The assembly tool292 may comprise virtual buttons 298 that are adapted to implement orinsert certain device elements and functions into HMI screens. Forexample, the push buttons 298 may add alarms, trending, graphics,macros, and so forth to a particular HMI screen. The update noticebanner 294 may indicate to a user that certain upgrades are availablefor download to the HMI. For example, a message on the update noticebanner 294 may indicate that new device elements for an object libraryresiding on the HMI are available from a particular website. In someembodiments, the banner may automatically connect a user to theparticular website when the banner 294 is selected (e.g., clicked onwith a pointer). The device properties view 296 may indicate certainproperties of a device element that is selected from the work screen290. For example, a graphic device representing a pump may be selectedon the work screen 290 and properties related to the device such as atag, a register, a physical address, operational logic, and so forth maythen be illustrated in the properties view 296. Other screens andsub-screens may be employed, and the present representation illustratesonly certain exemplary aspects in accordance with present techniques.

FIG. 14 is an exemplary representation of a device element configurationscreen in accordance with present embodiments. The device elementconfiguration screen may be generally referred to as screen 300.Specifically, the screen 300 may be a screen that is accessible from adevelopment environment (e.g., 262, 286) and that facilitates directconfiguration of device elements and graphics through a browser. Forexample, a user may select a push button 298 in the developmentenvironment 286 that adds an on/off button 302 to an HMI graphic. Uponadding the on/off button 302, sub-screen 304 may be accessed anddisplayed on the browser 282 to facilitate configuration of aspects ofthe on/off button. For example, visual properties (e.g., color and font)and dynamic links (e.g., associated I/O address) of the on/off button302 may be edited in sub-screen 304. Further, tools available in asub-screen 306 may be utilized to manipulate the on/off button graphicand/or add additional graphics and modules from a library, as describedabove. It should be noted that configuration of a device elementrelating to the on/off button through the browser is a directconfiguration of that element on the HMI in accordance with presenttechniques.

As discussed above, in accordance with one aspect of the presenttechnique, a global container is created that includes instances of allneeded device elements (both with and without screen representations).This greatly enhances the speed of updating screens and switchingbetween screens. At the same time, to reduce memory and processingrequirements, elements not required for a current screen are “torn off.”FIG. 15 is a flow diagram representing “tear off” functionality inaccordance with embodiments of the present techniques. Specifically,FIG. 15 illustrates transitioning between a first screen (i.e., screenA) and a second screen (i.e., screen B), wherein a component of a deviceelement is collapsed in the transition. In one embodiment, thecollapsing is facilitated by an unloading module 316, which removescertain aspects of the device element from memory (e.g., RAM), whilemaintaining the element instantiated and active.

Because of the quantity of device elements that can be associated with aparticular control and monitoring system, memory usage can become anissue. Indeed, excessive memory usage can impact performance of a systemby, for example, reducing display performance (e.g., cause a lengthyresponse time). Accordingly, embodiments of the present inventionincorporate tear off functionality. In other words, components notactive in a current screen view can be collapsed to save space. Thiscollapsing of components is achieved by unloading unnecessaryinformation. For example, in one embodiment, only basic characteristicsof a component are maintained in memory, while specific characteristicsare unloaded. Tear off functionality may include the ability to have anobject that provides less than a full description of itself using acommon portion of memory.

In a specific example, illustrated by FIG. 15, the device element 18 isrepresentative of a software clock that is collapsed in transition fromscreen A to screen B. In screen A, the clock includes a graphicalrepresentation of a functional clock. For example, it can include afunctional digital representation of a current time (e.g., 2:18 PM) thatcontinually updates as its functionality follows an internal HMI clock.In screen B, the clock is merely functional and is utilized to update ananimation graphic 318 on a designated interval. For example, componentsof the animation graphic 318 may move every few seconds based on thetiming of the functional clock 318. The graphic of the clock itself isnot illustrated in screen B. Thus, the components relating to thegraphic representation of the clock 318 are no longer being utilized inscreen B.

The device element 18 includes two basic property labels, which includea display property label 308 and a function property label 310. Thedisplay property label 308 relates to determining how the clock isgraphically represented and the function property label 310 relates todetermining how the clock operates (e.g., measures time). Each of theseproperty labels references associated properties, which may includedynamic property values. The display property label 308 is associatedwith properties including color, location, size, and text, which aregenerally referred to as display properties 312. The function propertylabel 310 is associated with properties including count, interval, time,and reset, which are generally referred to as function properties 314.

As discussed above, the display properties 312 are no longer utilized inscreen B. However, the function properties 314 are utilized in screen Bto manipulate the animation 318. Accordingly, in the illustratedembodiment, the display properties 312 are in a collapsed condition whena user is viewing screen B. Indeed, in the illustrated embodiment, thedisplay property label 308 remains without its associated displayproperties 312 in order to provide a limited description of theproperty. This improves display performance by reducing memory usage.

As also described above, connections can be established between deviceelements so as to cause immediate transmission of certain input datafrom a first device element to another upon its receipt. This highlypowerful feature allows different device elements to share data and actupon the data separately. That is, each device element acts inaccordance with its own “methods” or state engine. In a special, butparticularly useful case, two identical device elements (e.g., atdifferent locations on a network or in different devices) can “mirror”their operation by virtue of such event-driven data transmission (the“event” being the receipt of the data).

FIG. 16 illustrates device element mirroring in accordance with suchprogramming. Device element mirroring is also yet another technique forconserving memory. As discussed above, because of the quantity of deviceelements that can be associated with a particular control and monitoringsystem, memory usage can become an issue. Indeed, excessive memory usagecan impact performance of a system by, for example, reducing displayperformance (e.g., cause a lengthy response time). Sharing propertiesbetween device elements can result in redundancies that causeinefficiency and delay on an HMI. For example, excessive memory may beallocated to track or control a single measured value, which results inwasted memory. Similarly, excessive network traffic may result fromredundant information being transmitted, resulting in wasted networkresources. Accordingly, embodiments of the present techniquesincorporate device element mirroring.

Specifically, FIG. 16 illustrates a flow diagram that is representativeof two device elements sharing a particular property (e.g., a displayproperty). The primary object is generally referred to as first element320 and the secondary object is generally referred to as second element322. The second element 322 mirrors the first element 320 via aconnection 324. The connection 324 is between an output 326 of the firstelement 320 and an input 328 of the second element 322 and is triggeredby the event of receiving data from a source. That is, in one embodimentof the present techniques, an event of receiving data by the firstelement 320 triggers transmission of data to the second element 322 viathe connection 324.

In a specific example, as illustrated by FIG. 16, the first element 320is a device element relating to a first virtual gauge on a first HMI andthe second element 322 is a device element relating to a second virtualgauge on a second HMI. The first element 320 has a first state engine330 and a first property 332 (e.g., color). The second element 322 has asecond state engine 336 and a second property 388 (e.g., color). Itshould be noted that in other embodiments, the elements are not the sametype of element (i.e., both gauges). Indeed, in some embodiments theelements merely have similar functionality. Further, in someembodiments, even the properties are of different types.

In the illustrated embodiment, the first element 320 directlycommunicates with an event source. For example, if an emergency valve ina gas plant opens, the first 320 may detect a discrete event from theevent source, such as a PLC. Based on the detected event, the firstelement 320 may signal a related graphic property (e.g., 332) or asub-property (e.g., 334) to change colors (e.g., change from green tored). Further, based on the connection 324, the second element 322 willmirror the first element 320 by changing the color of its relatedproperty 338 or sub-property 340.

The two elements (320 and 322) are connected via the connection 324 thusfacilitating communication between the first state engine 330 and thesecond state engine 336. Accordingly, when the first property 332changes (e.g., changes from green to red), the first state engine 330communicates the change to the input 328 relating to the second stateengine 330 via the output 326. This component mirroring allows two ormore device elements (e.g., 320 and 322) to react in the same or similarfashion without consuming additional resources.

FIG. 17 is a block diagram summarizing a method described above forremotely configuring and implementing an application (e.g., graphicalinterface) using a standard interface in accordance with specificembodiments of the present techniques. The method may be generallyreferred to by reference numeral 342. Specifically, the method 342 mayincorporate various procedures relating to different phases ofoperation. While FIG. 17 separately delineates specific procedures, inother embodiments, individual procedures may be split into multipleprocedures or combined into a single procedure. In particular, themethod 342 comprises a connection phase 344, a configuration phase 346,and an operation phase 348.

The connection phase 344, in accordance with the present techniques,includes linking an HMI to a configuration station (block 350) andaccessing device elements and/or configuration software (block 352) thatare resident on the HMI via server and browser applications. Once accessis established, the device elements and the configuration applicationmay be utilized in the configuration phase 346 to develop interfacescreens for the HMI, via the configuration station. It should be notedthat linking the HMI and configuration station (block 350) may comprisethe utilization of a network interface, direct connect cable or anyother suitable connection, as discussed previously. Alternatively, ifremote access is not desired, a browser program on the HMI itself may beused to access the device elements and configuration application on theHMI without establishing a link to a remote device.

Once access to the configuration application is established, assembly ofa screen, which may take the form of a markup page, may begin in theconfiguration phase 346. The configuration phase may compriseconfiguring screen instructions (block 354) for the screen andselecting/linking device elements (block 356). Specifically, block 354may represent writing background instructions for coordinating aspectsof a typical input device with the markup page and for other relatedfunctions. For example, the screen instructions may coordinate certainkeyboard inputs with particular software functions (e.g., opening asoftware application when a particular button or virtual button ispushed). The screen may be further configured by selecting/linkingdevice elements (block 356) to aspects of the screen, thus incorporatingthe device elements as functional elements. This selecting/linkingprocedure (block 356) may include the creation/modification of deviceelements (block 358), and more particularly, of their properties, andthe importation of device elements from a resource library (block 360).For example, as discussed previously, a new device element may be addedto the HMI by retrieving it through the internet and downloading it tothe HMI. Additionally, the configuration tool on the HMI may allow auser to modify existing device elements and implement the modifiedversions in an operation environment.

In accordance with embodiments of the present techniques, the deviceelements being selected and linked in block 356 may requireconfiguration. Such a procedure is illustrated by block 362, which mayrepresent defining certain properties in device elements that enable thedevice elements to interface with external process components (e.g., I/Oaddresses on a PLC). It should be noted that this configurationprocedure (block 362) may be integral to the development of screens ormay occur in a separate procedure. For example, each time a deviceelement is linked to screens, it may require configuration.Alternatively, a device element may be linked and configured at anytime.

Block 364 represents a decision block. If the configuration is complete,the method may proceed to block 366. Alternatively, configuration maycontinue as illustrated. The result of the configuration phase inaccordance with embodiments of the present technique may be the creationof a display file, as illustrated by block 366. After being developed,this resulting display file may be implemented as an operationalgraphical interface (block 368) and utilized in the operation phase 348.

The operation phase 348 may comprise the actual implementation of theconfigured screen as a graphical interface on an HMI. Specifically, theprocedures for such an implementation may include running the displayfile (block 368) created in block 366. This may result in the display ofthe graphical interface on a user-viewable screen of the HMI or on ascreen linked to the HMI through server and browser applications, asillustrated by block 370. Further, running the display file (block 368)may enable the detection of system and user inputs (block 372) inaddition to activating the device elements (block 374). Indeed, an HMImay comprise embedded code and a server that enable a standard internetbrowser to navigate and implement a number of such graphical displaysand related device elements. Thus, embodiments of the present techniquesmay interact with a process to form a control and monitoring systemusing a standard web interface (e.g., HTML page).

FIG. 18 is a block diagram illustrating a method for assembling andimplementing an HMI adapted for remote configuration using a standardinterface in accordance with embodiments of the present techniques. Themethod may be generally referred to by reference numeral 376 and thestandard interface may comprise a browser. Method 376 may compriseassembling an HMI (block 378), installing a development package (e.g.,device elements) on the HMI (block 380), installing server software(e.g., a Web server) on the HMI (block 382), and linking the HMI to aremote computer (block 384). Once the link is established between theHMI and remote computer, a user may remotely configure the HMI usingimages (e.g., JPEG) of elements that are served up to the remotecomputer. As discussed above, the remote computer may have browsersoftware that is adapted to access the development package on the HMIvia the server. Further, as discussed above, the access may be limitedby security measures (e.g., passwords and user status). It should benoted, here again, that configuration need not be done directly on theHMI. Indeed, a virtual HMI may be established for configuration inaccordance with embodiments of the present techniques. For example, auser may configure a virtual HMI without having a physical HMI present.Once configured, the application created on the virtual HMI may betransferred to an actual HMI.

FIG. 19 is a flow diagram illustrating a manner in which the presenttechniques may support universal web-based programming and configurationvia device-side scripting. Specifically, FIG. 19 illustratesinteractions between a workstation 46 and an HMI 26. The interactionsare conducted through a browser 48 resident on the workstation 46. Inthe illustrated embodiment, the browser 48 sends queries 388 to the HMI26 and receiving responses 390 therefrom. The queries may relate tovarious activities, requests, and commands. For example, in oneembodiment a query is submitted to determine a property type for aconfigurable device element 18 resident on the HMI. The device elementmay include various properties. For example, in the illustratedembodiment, the element 18 has various property types, including a texttype 394, a floating point type 396, and numeric type 398. Theseproperty types are designated generally by reference number 392.Additionally, the element 18 may include an interface property type thatis designated 400.

The interface property type 400 is adapted to respond to a query byindicating that an interface type (e.g., IDispatch) is available.Further, the type 400 may respond to a separate query regardinginterface type with a specific type of interface script (e.g., storageinterface script). Indeed, the type 400 is adapted to enable aninterface that provides editing capabilities by, for example, bycreating a separate instance 386 of the browser with a window tofacilitate editing. This separate instance 386 is instantiated in aJavaScript in accordance with embodiments of the present techniques.

In one embodiment of the present technique, the HMI 26 responds to aquery regarding property type for the configurable element 18 with acomplex editor 402 having a storage interface that mimics a programminglanguage. The editor, which may be a simple text editor, is adapted topermit code stored in the interface type property to be edited. Thisapproach thus permits even extremely extensive code (e.g., source code)to be stored in a device element and accessed in exactly the same way asdescribed above for editing. Separate storage and loading of the code,compilation of the code, and use of specially designed programming toolsare thus avoided.

While only certain features of the invention have been illustrated anddescribed herein, many modifications and changes will occur to thoseskilled in the art. It is, therefore, to be understood that the appendedclaims are intended to cover all such modifications and changes as fallwithin the true spirit of the invention.

1. A method for configuring an interface, comprising: creating first andsecond device elements capable of communicating signals to one another,each device element including a predetermined functionality; andcreating a connection between the first and second device elements, theconnection facilitating an event-based transfer of signals from thefirst device element to the second device element, wherein the firstdevice element transmits the received signals or data resulting from itsfunctionality acting upon the received signals to the second deviceelement upon receipt of the signals by the first device element, andwherein each device element acts upon the signals in accordance with itsrespective functionality.
 2. The method of claim 1, wherein thefunctionalities of the first and second device elements are similarlyconfigured such that the first and second device elements mirror theirfunctionality.
 3. The method of claim 1, wherein at least one of thefirst and second device elements includes a visual representation forinclusion in a user viewable display.
 4. The method of claim 3, whereinboth the first and second device elements includes a respective visualrepresentation for inclusion in respective viewable displays.
 5. Themethod of claim 4, wherein the first and second device element visualrepresentations are similar to one another.
 6. The method of claim 3,comprising changing the visual representation as a result of thefunctionality of the respective device element.
 7. The method of claim1, wherein the first and second device elements have differentfunctionalities.
 8. A method for configuring an interface, comprising:creating first and second device elements capable of communicatingsignals to one another, the device elements including generallyidentical functionalities and generally identical visual representationsfor display on respective interface devices; and creating a connectionbetween the first and second device elements, the connectionfacilitating an event-based transfer of signals from the first deviceelement to the second device element, wherein the first device elementtransmits the received signals or data resulting from its functionalityacting upon the received signals to the second device element uponreceipt of the signals by the first device element, and wherein thefunctionalities of the device elements result in similar changes to thevisual representations on the respective interface devices in responseto the signals.
 9. The method of claim 8, wherein the first and seconddevice elements are COM objects.
 10. A method for configuring aninterface, comprising: creating first and second device elements capableof communicating signals to one another, each device element including afunctionality, and at least one of the device elements includes a visualrepresentation for inclusion in an interface display; creating aconnection between the first and second device elements, the connectionfacilitating an event-based transfer of signals from the first deviceelement to the second device element, wherein the first device elementtransmits the received signals or data resulting from its functionalityacting upon the received signals to the second device element uponreceipt of the signals by the first device element, and wherein eachdevice elements acts upon the signal in accordance with its respectivefunctionality; displaying the visual representation in an interfacedisplay and changing the visual representation in response to receipt ofthe signals and the functionality of one of the device elements; andexecuting a control function in a control and monitoring system inresponse to receipt of the signals and the functionality of the other ofthe device elements.
 11. The method of claim 10, wherein the deviceelements are included in separate physical devices.
 12. The method ofclaim 11, wherein the physical devices are coupled to one another by anindustrial control and monitoring network.
 13. A configurable interfacesystem, comprising: a first device element having a first functionalityand a first visual representation for display on a first interface; asecond device element having a second functionality and a second visualrepresentation for display on a second interface; a connectionconfigured between the first and second device elements by which thefirst device element transfers received signals or data resulting fromits functionality acting upon received signals received by the firstdevice element to the second device element in response to receipt ofthe signals by the first device element.
 14. The system of claim 13,wherein first and second functionalities are generally identical to oneanother.
 15. The system of claim 13, wherein the first and second visualrepresentations are generally identical to one another.
 16. The systemof claim 13, wherein the first and second interfaces are physicallyremote from one another.
 17. The system of claim 13, wherein the firstand second device elements are COM objects.
 18. The system of claim 13,including a design-time environment stored on the first or the secondinterface for configuration of the first or the respective deviceelement.
 19. The system of claim 18, including a server resident on thefirst or the second interface for serving the design-time environment toa general purpose viewer for configuration of the respective deviceelement.
 20. A configurable interface system, comprising: a first deviceelement having a first functionality and a visual representation fordisplay on an interface; a second device element having a secondfunctionality; and a connection configured between the first and seconddevice elements by which the first device element transfers receivedsignals or data resulting from its functionality acting upon receivedsignals received by the first device element to the second deviceelement in response to receipt of the signals by the first deviceelement; wherein the first functionality of the first device elementcauses display of the visual representation in an interface display andchanges the visual representation in response to receipt of the signals,and the second state engine of the second device element executes acontrol function in a control and monitoring system in response toreceipt of the signals.